home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Libraries / TurboTCP 1.0.1 / TurboTCP.source / CTCPResolverCall.h < prev    next >
Text File  |  1993-12-10  |  6KB  |  203 lines
  1. /*
  2. ** CTCPResolverCall.h
  3. **
  4. **    TurboTCP support library
  5. **    TCP resolver class
  6. **
  7. **    Copyright © 1993, FrostByte Design / Eric Scouten
  8. **
  9. */
  10.  
  11.  
  12. #pragma once
  13.  
  14. #ifndef TurboTCPHeaders
  15.     #include <CObject.h>
  16.     #include <CCollaborator.h>
  17.     #include <MacTCPCommonTypes.h>
  18.     #include "TurboTCP.const.h"
  19. #endif
  20.  
  21.  
  22. // reason codes for TCP resolver call notifications
  23.  
  24. enum {
  25.     tcpResolverStrToAddr,            // StrToAddr completed        info = (struct hostInfo *)
  26.     tcpResolverAddrToName,            // AddrToName completed    info = (struct hostInfo *)
  27.     tcpResolverHInfo,                // HInfo completed            info = (struct returnRec *)
  28.     tcpResolverMXInfo,                // MXInfo completed            info = (struct returnRec *)
  29.  
  30.     tcpResolverLastChange = tcpResolverMXInfo
  31. };
  32.  
  33.  
  34. /*
  35. **    A modified version of <AddressXlation.h> is included here since none of the procedures
  36. **    of dnr.c are used. (The functionality is instead included in the CTCPResolverCall.cp file.)
  37. **    This version includes all of the typedefs, but omits the procedural definitions.
  38. */
  39.  
  40. #define NUM_ALT_ADDRS    4
  41.  
  42. typedef OSErr (*DNRProcPtr) (long, ...);
  43. typedef ProcPtr EnumResultProcPtr;
  44. typedef ProcPtr ResultProcPtr;
  45. typedef ProcPtr ResultProc2Ptr;
  46.  
  47. typedef struct hostInfo {
  48.     long            rtnCode;
  49.     char            cname [255];
  50.     unsigned long    addr [NUM_ALT_ADDRS];
  51. };
  52.  
  53. typedef enum AddrClasses {
  54.     A = 1,
  55.     NS,
  56.     CNAME = 5,
  57.     HINFO = 13,
  58.     MX = 15,
  59.     lastClass = 32767
  60. } AddrClasses; 
  61.  
  62. typedef struct HInfoRec {
  63.     char                cpuType [30];
  64.     char                osType [30];
  65.     };
  66.  
  67. typedef struct MXRec {
  68.     unsigned short        preference;
  69.     char                exchange [255];
  70.     };
  71.     
  72. typedef struct returnRec {
  73.     short            rtnCode;
  74.     char                cname [255];
  75.     union {
  76.         unsigned long    addr [NUM_ALT_ADDRS];
  77.         struct HInfoRec    hinfo;
  78.         struct MXRec    mx;
  79.     } rdata;
  80. };
  81.  
  82. typedef struct cacheEntryRecord {
  83.     char                *cname;
  84.     unsigned short        type;
  85.     unsigned short        cacheClass;
  86.     unsigned long        ttl;
  87.     union {
  88.         char            *name;
  89.         ip_addr        addr;
  90.     } rdata;
  91. };
  92.  
  93.  
  94. // notification types for PostponeNotify()
  95.  
  96. typedef enum {
  97.     notifNone,
  98.     notifStrToAddr,
  99.     notifAddrToName,
  100.     notifHInfo,
  101.     notifMXInfo
  102. } NotifType;
  103.  
  104.  
  105. /*______________________________________________________________________
  106. **
  107. ** CTCPResolverCall
  108. **
  109. **    This class implements the core DNR calls. It is like the CTCPAsyncCall in that the call
  110. **    object is created to allow the call to persist beyond the scope of originating method.
  111. **    However, access to this object is not restricted; your application classes can and often
  112. **    will interact with the CTCPResolverCall object.
  113. **
  114. **    IMPORTANT: This object is a descendant of CCollaborator. Your application class should
  115. **    make itself a dependent of this object so that it may receive notification of resolver
  116. **    call completions.
  117. **
  118. **    Each resolver object may support only one asynchronous resolver call at a time.
  119. **    You may create several resolver objects to simultaneously process several calls,
  120. **    so long as you respect MacTCP’s limit of 8 resolver calls open at once. The CTCPDriver
  121. **    acts as a referee to prohibit more than 8 simultaneous calls.
  122. **
  123. **    One set of methods (Do...) is called to initiate resolver calls. These are the methods you
  124. **    will typically call from your application classes. These methods initiate asynchronous
  125. **    calls to the DNR code resource. When the calls are completed, the notification is passed
  126. **    to another set of methods (Handle...). The Handle… methods return notification to your
  127. **    class by means of the BroadcastChange mechanism. The exception to this is the DoAddrToStr
  128. **    method which returns the result immediately.
  129. **
  130. **    The userDataPtr fields of each of the calls are used by the resolver object to get
  131. **    notification of completion, and are not available to the caller.
  132. **
  133. **    The CTCPDriver object takes care of opening and closing the DNR code resource; it uses
  134. **    the OpenResolver and CloseResolver methods. You should not call these methods from your
  135. **    application classes.
  136. **
  137. **    The EnumCache call is not implemented in TurboTCP.
  138. **
  139. */
  140.  
  141. class CTCPResolverCall : public CCollaborator {
  142.  
  143. protected:
  144.     Boolean            inUse;                // resolver in use; can’t accept calls
  145.     Boolean            disposeOnCompletion;    // dispose of resolver call once completed
  146.     struct hostInfo        theHostInfo;            // parms for StrToAddr
  147.     struct returnRec    theHMXInfo;            // parms for HInfo or MXInfo
  148.     char                hostName [255];        // name of user host
  149.     NotifType            pendingNotify;            // resolver is in ProcessNotify queue
  150.     static Handle        macDNRcode;            // the DNR code resource’s handle
  151.     static DNRProcPtr    macDNRentry;            // the DNR code entry point
  152.     TurboTCPQElem        qEntry;                // completion queue entry
  153.  
  154.  
  155.     // initialize/destroy resolver
  156.  
  157. public:
  158.     void ITCPResolverCall (void);
  159.     virtual void Dispose (void);
  160.  
  161.  
  162.     // initiate resolver calls
  163.     
  164.     void DoStrToAddr (char *theHostName);
  165.     void DoAddrToStr (ip_addr theIPaddr, char *theString);
  166.     void DoAddrToName (ip_addr theIPaddr);
  167.     void DoHInfo (char *theHostName);
  168.     void DoMXInfo (char *theHostName);
  169.  
  170.  
  171.     // respond to completion of resolver calls
  172.  
  173.     virtual void ProcessNotify (void);
  174. protected:
  175.     virtual void HandleStrToAddr (void);
  176.     virtual void HandleAddrToName (void);
  177.     virtual void HandleHInfo (void);
  178.     virtual void HandleMXInfo (void);
  179.  
  180.  
  181.     // open/close TCP resolver
  182.  
  183. public:
  184.     static void OpenResolver (void);
  185.     static void CloseResolver (void);
  186. protected:
  187.     static short OpenTheDNR (void);
  188.     static short SearchFolderForDNRP (long targetType, long targetCreator,
  189.                                 short vRefNum, long dirID);
  190.     static void GetSystemFolder (short *vRefNumP, long *dirIDP);
  191.     static void GetCPanelFolder (short *vRefNumP, long *dirIDP);
  192.  
  193.  
  194.     // interrupt-level methods: delay processing for non-interrupt status
  195.  
  196.     virtual void PostponeNotify (NotifType theNotifType);
  197.     static pascal void PostponeStrToAddr (struct hostInfo *hostInfoPtr, char *userDataPtr);
  198.     static pascal void PostponeAddrToName (struct hostInfo *hostInfoPtr, char *userDataPtr);
  199.     static pascal void PostponeHInfo (struct returnRec *returnRecPtr, char *userDataPtr);
  200.     static pascal void PostponeMXInfo (struct returnRec *returnRecPtr, char *userDataPtr);
  201.  
  202. };
  203.